package models

import (
	"LoveU/utils"

	"github.com/astaxie/beego"

	"github.com/astaxie/beego/orm"
)

// 添加好友（申请）
func AddFriend(userid int64, friendid int64, attach string) int64 {
	if getUser(userid) == nil {
		return utils.USER_NOT_FOUND
	}
	o := orm.NewOrm()
	// qs := o.QueryTable("friendrequest")
	if getUser(friendid) == nil {
		return utils.USER_NOT_FOUND
	}

	qs := o.QueryTable("friend")
	count, err0 := qs.Filter("userid", userid).Filter("friendid", friendid).Count()
	if err0 != nil {
		return utils.DATABASE_ERROR
	}
	if count > 0 {
		return utils.IS_A_FRIEND
	}
	//检查好友申请表
	qs = o.QueryTable("friendrequest")
	//检查用户跟申请人是否有对应关系, 此为有存在申请关系，没有同意
	count1, err1 := qs.Filter("userid", userid).Filter("requestedid", friendid).Filter("agree", 0).Count()

	// count2, err2 := qs.Filter("userid", userid).Filter("requestedid", friendid).Filter("agree", 1).Count()
	if err1 != nil {
		return utils.DATABASE_ERROR
	}
	if count1 == 0 {
		addFriendRequest(userid, friendid, attach)
		return utils.FRIENDS_REQUEST_OK
	}
	beego.Error(count1)
	if count1 == 1 {
		return utils.FRIENDS_REQUEST_WAITING
	}
	return utils.UNKNOWN_ERROR
}

//根据名字添加好友（申请）
func AddFriendStr(userid int64, username string, attach string) int64 {
	if getUser(userid) == nil {
		return utils.USER_NOT_FOUND
	}
	o := orm.NewOrm()
	// qs := o.QueryTable("friendrequest")
	if getUserByname(username) == nil {
		return utils.USER_NOT_FOUND
	}

	friendid := getUserIDByname(username)
	beego.Error("friendid", friendid)

	qs := o.QueryTable("friend")
	count, err0 := qs.Filter("userid", userid).Filter("friendid", friendid).Count()
	if err0 != nil {
		return utils.DATABASE_ERROR
	}
	if count > 0 {
		return utils.IS_A_FRIEND
	}
	//检查好友申请表
	qs = o.QueryTable("friendrequest")
	//检查用户跟申请人是否有对应关系, 此为有存在申请关系，没有同意
	count1, err1 := qs.Filter("userid", userid).Filter("requestedid", friendid).Filter("agree", 0).Count()

	// count2, err2 := qs.Filter("userid", userid).Filter("requestedid", friendid).Filter("agree", 1).Count()
	if err1 != nil {
		return utils.DATABASE_ERROR
	}
	if count1 == 0 {
		addFriendRequest(userid, friendid, attach)
		return utils.FRIENDS_REQUEST_OK
	}
	beego.Error(count1)
	if count1 == 1 {
		return utils.FRIENDS_REQUEST_WAITING
	}
	return utils.UNKNOWN_ERROR
}

// 将好友写入到表中
func writeToFriend(userid, friendid int64) int64 {
	o := orm.NewOrm()
	friend := new(Friend)
	friend.Userid = userid
	friend.Friendid = friendid
	_, err3 := o.Insert(friend)
	if err3 != nil {
		return utils.DATABASE_ERROR
	}
	friend1 := new(Friend)
	friend1.Userid = friendid
	friend1.Friendid = userid
	_, err3 = o.Insert(friend1)
	if err3 != nil {
		return utils.DATABASE_ERROR
	}
	return utils.FRIENDS_REPLY_OK
}

// 添加好友申请
// 暂为AddFriend的子功能，请勿单独使用
func addFriendRequest(userid, friendid int64, attach string) int64 {
	o := orm.NewOrm()
	request := new(Friendrequest)
	request.Userid = userid
	request.Requestedid = friendid
	request.Attach = attach
	request.Agree = 0
	_, err := o.Insert(request)
	if err != nil {
		return utils.DATABASE_ERROR
	}
	return utils.OK
}

// 确认好友申请
// 一个人只可以向另一个人申请一次添加好友，被拒绝后才可以继续申请
// 被忽略状态下不能向同一个用户继续添加好友
// agree可以为1或者2
// 返回参数：
// utils.LOGIN_USRWRONG
// utils.NOT_A_FRIEND
// utils.FRIENDS_REQUEST_NOT_EXIST
// utils.ARGUMENT_DENIED
// utils.FRIENDS_REQUEST_OK
func ConfirmFriend(userid int64, friendid int64, agree int64) int64 {
	if getUser(userid) == nil {
		return utils.USER_NOT_FOUND
	}
	if getUser(friendid) == nil {
		return utils.USER_NOT_FOUND
	}
	o := orm.NewOrm()
	qs := o.QueryTable("friendrequest")
	friendrequest := new(Friendrequest)
	err := qs.Filter("userid", friendid).Filter("requestedid", userid).Filter("agree", 0).One(friendrequest)
	if err != nil {
		return utils.FRIENDS_REQUEST_NOT_EXIST
	}

	switch agree {
	case 1:
		//将好友添加到好友表
		status := writeToFriend(userid, friendid)
		// 确认添加好友成功
		beego.Error(status)
		// 同意申请
		friendrequest.Agree = agree
		o.Update(friendrequest)
		return status
	case 2:
		// 拒绝申请
		friendrequest.Agree = agree
		o.Update(friendrequest)
		return utils.FRIENDS_REPLY_DENY
	default:
		return utils.ARGUMENT_DENIED
	}

}

// 返回我的申请
func GetMyRequest(userid int64) ([]*Friendrequest, int64) {
	o := orm.NewOrm()
	qs := o.QueryTable("friendrequest")
	friendrequests := make([]*Friendrequest, 0)
	_, err := qs.Filter("userid", userid).All(&friendrequests)
	if err != nil {
		return nil, utils.UNKNOWN_ERROR
	}
	return friendrequests, utils.FRIENDS_REPLY_OK
}

// 返回好友申请
// 返回值：
// utils.UNKNOWN_ERROR
// utils.FRIENDS_REPLY_OK
func GetRequest(userid, page, pagesize int64) (*utils.Pagination, int64) {
	o := orm.NewOrm()
	qs := o.QueryTable("friendrequest")
	friendrequests := make([]*Friendrequest, 0)

	startLine := (page - 1) * pagesize
	sum, _ := qs.Filter("requestedid", userid).Count()
	_, err := qs.OrderBy("-date").Filter("requestedid", userid).Limit(pagesize).Offset(startLine).All(&friendrequests)

	if err != nil {
		return nil, utils.UNKNOWN_ERROR
	}
	// return friendrequests, utils.FRIENDS_REPLY_OK
	var pagenum int64
	if sum%pagesize == 0 {
		pagenum = sum / pagesize
	} else {
		pagenum = sum/pagesize + 1
	}
	data := &utils.Pagination{
		Page:      page,
		Pagesize:  pagesize,
		Pagecount: pagenum,
		Sum:       sum,
		Data:      friendrequests,
	}
	return data, utils.FRIENDS_REPLY_OK
}

// 删除好友
// 返回参数：
// utils.LOGIN_USRWRONG
// utils.NOT_A_FRIEND
// utils.UNKNOWN_ERROR
// utils.FRIENDS_REMOVE_OK
func DeleteFriend(userid int64, friendid int64) int64 {
	if getUser(userid) == nil {
		return utils.LOGIN_USRWRONG
	}
	if getUser(friendid) == nil {
		return utils.LOGIN_USRWRONG
	}
	o := orm.NewOrm()
	qs := o.QueryTable("friend")
	friend := new(Friend)
	err := qs.Filter("userid", userid).Filter("friendid", friendid).One(friend)
	if err != nil {
		return utils.NOT_A_FRIEND
	}
	_, err = o.Delete(friend)
	if err != nil {
		return utils.UNKNOWN_ERROR
	} else {
		// 互相删除好友
		err = qs.Filter("userid", friendid).Filter("friendid", userid).One(friend)
		_, err = o.Delete(friend)
		if err != nil {
			return utils.UNKNOWN_ERROR
		}
		return utils.FRIENDS_REMOVE_OK
	}
}

// 返回好友列表
func GetFriends(userid int64) ([]*UserReturn, int64) {
	var users []*UserReturn

	o := orm.NewOrm()
	qs := o.QueryTable("friend")
	friends := make([]*Friend, 0)
	_, err := qs.Filter("userid", userid).All(&friends)
	if err != nil {
		return nil, utils.UNKNOWN_ERROR
	}
	var user *User
	// var userReturn *UserReturn
	for _, tFriend := range friends {
		user = getUser(tFriend.Friendid)
		userReturn := new(UserReturn)
		userReturn.Id = user.Id
		userReturn.Name = user.Name
		userReturn.Avatar = getUserAvatar(user.Id)
		users = append(users, userReturn)
	}
	return users, utils.FRIENDS_LIST_OK
}

// 获取全部好友的id
// 返回值：
// utils.UNKNOWN_ERROR：系统错误
// 537：返回信息成功
func GetFriendsId(userid int64) ([]*int64, int64) {
	var friendids []*int64
	o := orm.NewOrm()
	qs := o.QueryTable("friend")
	friends := make([]*Friend, 0)
	_, err := qs.Filter("userid", userid).All(&friends)
	if err != nil {
		return nil, utils.UNKNOWN_ERROR
	}
	for _, ids := range friends {
		friendids = append(friendids, &(ids.Friendid))
	}
	return friendids, 537
}

// 检查对方是不是你的好友
func CheckIsFriend(userid, friendid int64) bool {
	o := orm.NewOrm()
	qs := o.QueryTable("friend")
	nums, err := qs.Filter("userid", userid).Filter("friendid", userid).Count()
	if err != nil {
		beego.Error(nums)
		return false
	}
	return true
}
